// API接口管理 - 统一管理所有API调用
// 提供良好的可维护性和扩展性

(function(window) {
    'use strict';
    
    // API配置
    const API_CONFIG = {
        // 基础配置
        BASE_URL: 'http://127.0.0.1:5700',
        TIMEOUT: 10000, // 10秒超时
        
        // 接口版本
        VERSION: 'v1',
        
        // 请求头配置
        HEADERS: {
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        }
    };
    
    // API接口地址配置
    const API_ENDPOINTS = {
        // 文件相关接口
        files: {
            list: '/fileInfoList',           // 获取文件列表
            upload: '/fileInfo',             // 上传文件
            download: '/download',           // 下载文件
            delete: '/deleteFile',           // 删除文件
            rename: '/renameFile',           // 重命名文件
            info: '/fileDetail',             // 获取文件详情
            search: '/searchFiles'           // 搜索文件
        },
        
        // 用户相关接口（预留）
        user: {
            login: '/user/login',
            logout: '/user/logout',
            profile: '/user/profile',
            register: '/user/register'
        },
        
        // 系统相关接口（预留）
        system: {
            status: '/system/status',
            config: '/system/config',
            stats: '/system/stats'
        }
    };
    
    // HTTP状态码处理
    const HTTP_STATUS = {
        SUCCESS: 200,
        CREATED: 201,
        BAD_REQUEST: 400,
        UNAUTHORIZED: 401,
        FORBIDDEN: 403,
        NOT_FOUND: 404,
        SERVER_ERROR: 500
    };
    
    // API响应处理器
    class APIResponse {
        constructor(data, status, message) {
            this.data = data;
            this.status = status;
            this.message = message;
            this.success = status === HTTP_STATUS.SUCCESS;
        }
        
        // 检查响应是否成功
        isSuccess() {
            return this.success && this.data;
        }
        
        // 获取错误信息
        getError() {
            return this.message || '请求失败';
        }
        
        // 获取数据
        getData() {
            return this.data || null;
        }
    }
    
    // HTTP请求工具
    class HttpClient {
        constructor() {
            this.instance = axios.create({
                baseURL: API_CONFIG.BASE_URL,
                timeout: API_CONFIG.TIMEOUT,
                headers: API_CONFIG.HEADERS
            });
            
            // 请求拦截器
            this.instance.interceptors.request.use(
                config => {
                    // 添加时间戳防止缓存
                    config.params = {
                        ...config.params,
                        _t: Date.now()
                    };
                    
                    console.log('📤 API Request:', config.method.toUpperCase(), config.url, config.params || config.data);
                    return config;
                },
                error => {
                    console.error('❌ Request Error:', error);
                    return Promise.reject(error);
                }
            );
            
            // 响应拦截器
            this.instance.interceptors.response.use(
                response => {
                    console.log('📥 API Response:', response.config.url, response.data);
                    return new APIResponse(response.data, response.status, response.data.msg);
                },
                error => {
                    console.error('❌ Response Error:', error.config?.url, error.message);
                    
                    let message = '网络请求失败';
                    let status = HTTP_STATUS.SERVER_ERROR;
                    
                    if (error.response) {
                        status = error.response.status;
                        message = error.response.data?.msg || `服务器错误 (${status})`;
                    } else if (error.code === 'ECONNABORTED') {
                        message = '请求超时，请稍后重试';
                    } else if (error.code === 'NETWORK_ERROR') {
                        message = '网络连接失败，请检查网络';
                    }
                    
                    return Promise.resolve(new APIResponse(null, status, message));
                }
            );
        }
        
        // GET请求
        get(url, params = {}) {
            return this.instance.get(url, { params });
        }
        
        // POST请求
        post(url, data = {}) {
            return this.instance.post(url, data);
        }
        
        // PUT请求
        put(url, data = {}) {
            return this.instance.put(url, data);
        }
        
        // DELETE请求
        delete(url, params = {}) {
            return this.instance.delete(url, { params });
        }
    }
    
    // API服务类
    class APIService {
        constructor() {
            this.http = new HttpClient();
        }
        
        // 文件相关API
        files = {
            // 获取文件列表
            getList: (params = {}) => {
                const defaultParams = {
                    page: 0,
                    rows: 36,
                    file_type:''
                };
                if (params.file_type == '2' ){
                    params.file_type = null
                    params.file_type_list = JSON.stringify([3, 4, 5])
                } else if (params.file_type == '0' && params.file_type == 0 ){
                    params.file_type = null
                }
                return this.http.get(API_ENDPOINTS.files.list, { ...defaultParams, ...params });
            },
            
            // 上传文件
            upload: (formData) => {
                return this.http.post(API_ENDPOINTS.files.upload, formData);
            },
            
            // 获取文件详情
            getDetail: (fileId) => {
                return this.http.get(API_ENDPOINTS.files.info, { id: fileId });
            },
            
            // 删除文件
            delete: (fileId) => {
                return this.http.delete(API_ENDPOINTS.files.delete, { id: fileId });
            },
            
            // 重命名文件
            rename: (fileId, newName) => {
                return this.http.put(API_ENDPOINTS.files.rename, { id: fileId, name: newName });
            },
            
            // 搜索文件
            search: (keyword, params = {}) => {
                return this.http.get(API_ENDPOINTS.files.search, { 
                    keyword, 
                    ...params 
                });
            },
            
            // 获取下载链接
            getDownloadUrl: (fileId) => {
                return `${API_CONFIG.BASE_URL}${API_ENDPOINTS.files.download}/${fileId}`;
            }
        };
        
        // 用户相关API（预留扩展）
        user = {
            login: (credentials) => {
                return this.http.post(API_ENDPOINTS.user.login, credentials);
            },
            
            logout: () => {
                return this.http.post(API_ENDPOINTS.user.logout);
            },
            
            getProfile: () => {
                return this.http.get(API_ENDPOINTS.user.profile);
            }
        };
        
        // 系统相关API（预留扩展）
        system = {
            getStatus: () => {
                return this.http.get(API_ENDPOINTS.system.status);
            },
            
            getStats: () => {
                return this.http.get(API_ENDPOINTS.system.stats);
            }
        };
    }
    
    // 全局API实例
    const api = new APIService();
    
    // 暴露到全局
    window.API = api;
    window.API_CONFIG = API_CONFIG;
    window.HTTP_STATUS = HTTP_STATUS;
    
    // 兼容性：暴露常用方法
    window.getFileList = api.files.getList;
    window.uploadFile = api.files.upload;
    window.deleteFile = api.files.delete;
    
    console.log('🚀 API Manager initialized successfully');
    
})(window);

// 使用示例和文档
/*
// 基础使用
API.files.getList({ page: 0, rows: 20 })
    .then(response => {
        if (response.isSuccess()) {
            console.log('文件列表:', response.getData());
        } else {
            console.error('获取失败:', response.getError());
        }
    });

// 上传文件
const formData = new FormData();
formData.append('file', fileObject);
API.files.upload(formData)
    .then(response => {
        if (response.isSuccess()) {
            console.log('上传成功');
        }
    });

// 搜索文件
API.files.search('关键词', { page: 0, rows: 10 })
    .then(response => {
        // 处理搜索结果
    });

// 配置修改（在初始化前）
API_CONFIG.BASE_URL = 'https://your-api-domain.com';
API_CONFIG.TIMEOUT = 15000;
*/